home *** CD-ROM | disk | FTP | other *** search
/ PC World Interactive 7 / PC World Interactive 7.iso / program / ctutor.exe / TEXT / CHAP11.TXT < prev    next >
Text File  |  1994-05-15  |  31KB  |  638 lines

  1.  
  2.  
  3.  
  4.                                                        Chapter 11
  5.                                             STRUCTURES AND UNIONS
  6.  
  7. WHAT IS A STRUCTURE?
  8. -----------------------------------------------------------------
  9. A structure is a user defined data type.  Using   ===============
  10. a structure you have the ability to define a         STRUCT1.C
  11. new type of data considerably more complex than   ===============
  12. the types we have been using.  A structure is a 
  13. combination of several different previously defined data types, 
  14. including other structures we have defined.  A simple definition 
  15. is, "a structure is a grouping of related data in a way 
  16. convenient to the programmer or user of the program."  The best 
  17. way to understand a structure is to look at an example, so if you 
  18. will load and display STRUCT1.C, we will do just that.
  19.  
  20. The program begins with a structure definition.  The keyword 
  21. struct is followed by three simple variables between the braces, 
  22. which are the components of the structure.  After the closing 
  23. brace, you will find two variable names listed, boy, and girl.  
  24. According to the definition of a structure, boy is now a variable 
  25. composed of three elements, initial, age, and grade.  Each of the 
  26. three fields are associated with boy, and each can store a 
  27. variable of its respective type.  The variable named girl is also 
  28. a variable containing three fields with the same names as those 
  29. of boy but are actually different variables.  We have therefore 
  30. defined 6 simple variables, but they are grouped into 2 variables 
  31. of a structure type. 
  32.  
  33.  
  34. A SINGLE COMPOUND VARIABLE
  35. -----------------------------------------------------------------
  36. Lets examine the variable named boy more closely.  As stated 
  37. above, each of the three elements of boy are simple variables and 
  38. can be used anywhere in a C program where a variable of their 
  39. type can be used.  For example, the age element is an integer 
  40. variable and can therefore be used anywhere in a C program where 
  41. it is legal to use an integer variable, in calculations, as a 
  42. counter, in I/O operations, etc.  We now have the problem of 
  43. defining how to use the simple variable named age which is a part 
  44. of the compound variable named boy.  To do so we use both names 
  45. with a decimal point between them with the major name first.  
  46. Thus boy.age is the complete variable name for the age field of 
  47. boy.  This construct can be used anywhere in a C program that it 
  48. is desired to refer to this field.  In fact, it is illegal to use 
  49. the name boy or age alone because they are only partial 
  50. definitions of the complete field.  Alone, the names refer to 
  51. nothing.  (Actually the name boy alone does have meaning when 
  52. used with a modern C compiler.  We will discuss this later.)
  53.  
  54.  
  55.  
  56.  
  57.                                                         Page 11-1
  58.  
  59.                                Chapter 11 - Structures and Unions
  60.  
  61. ASSIGNING VALUES TO THE VARIABLES
  62. -----------------------------------------------------------------
  63. Using the above definition, we can assign a value to each of the 
  64. three fields of boy and each of the three fields of girl.  Note 
  65. carefully that boy.initial is actually a char type variable, 
  66. because it was defined as one in the structure, so it must be 
  67. assigned a character of data.  In line 12, boy.initial is 
  68. assigned the character R in agreement with the above rules.  The 
  69. remaining two fields of boy are assigned values in accordance 
  70. with their respective types.  Finally the three fields of girl 
  71. are assigned values but in a different order to illustrate that 
  72. the order of assignment is not critical.  You will notice that 
  73. we used the value of the boy's age when we defined the girl's 
  74. age.  This illustrates the use of one member of the structure.  
  75. Figure 11-1 is a graphical representation of the data following 
  76. execution of line 18.
  77.  
  78.  
  79. HOW DO WE USE THE RESULTING DATA?
  80. -----------------------------------------------------------------
  81. Now that we have assigned values to the six simple variables, we 
  82. can do anything we desire with them.  In order to keep this first 
  83. example simple, we will simply print out the values to see if 
  84. they really do exist as assigned.  If you carefully inspect the 
  85. printf() statements, you will see that there is nothing special 
  86. about them.  The compound name of each variable is specified 
  87. because that is the only valid name by which we can refer to 
  88. these variables.
  89.  
  90. Structures are a very useful method of grouping data together in 
  91. order to make a program easier to write and understand.  This 
  92. first example is too simple to give you even a hint of the value 
  93. of using structures, but continue on through these lessons and 
  94. eventually you will see the value of using structures.  Compile 
  95. and run STRUCT1.C and observe the output.
  96.  
  97.  
  98. AN ARRAY OF STRUCTURES
  99. -----------------------------------------------------------------
  100. Load and display the next program named         =================
  101. STRUCT2.C.  This program contains the same          STRUCT2.C
  102. structure definition as before but this time    =================
  103. we define an array of 12 variables named 
  104. kids.  It should be clear that this program contains 12 times 
  105. 3 = 36 simple variables, each of which can store one item of data 
  106. provided that it is of the correct type.  We also define a simple 
  107. variable named index for use in the for loops.
  108.  
  109. In order to assign each of the fields a value, we use a for loop 
  110. and each pass through the loop results in assigning a value to 
  111. each of the fields of one structure variable.  One pass through 
  112. the loop assigns all of the values for one of the kids.  This 
  113. would not be a very useful way to assign data in a real 
  114.  
  115.                                                         Page 11-2
  116.  
  117.                                Chapter 11 - Structures and Unions
  118.  
  119. situation, but a loop could read the data in from a file and 
  120. store it in the correct fields in a real application.  You might 
  121. consider this the crude beginning of a data base, which it is.
  122.  
  123. In the next few instructions of this program we assign new values 
  124. to some of the fields to illustrate the method used to accomplish 
  125. this.  It should be self explanatory, so no additional comments 
  126. will be given.  Figure 11-2 is a graphical representation of the 
  127. data for this program following execution of line 22.
  128.  
  129.  
  130. A RECENT UPGRADE TO THE C LANGUAGE
  131. -----------------------------------------------------------------
  132. All good C compilers will allow you to copy an entire structure 
  133. with one statement.  This is a fairly recent addition to the C 
  134. language and is a part of the ANSI standard, so you should feel 
  135. free to use it with your C compiler if it is available.  Line 24 
  136. is an example of using a structure assignment.  In this 
  137. statement, all 3 fields of kids[4] are copied into their 
  138. respective fields of kids[10].
  139.  
  140.  
  141. WE FINALLY DISPLAY ALL OF THE RESULTS
  142. -----------------------------------------------------------------
  143. The last few statements contain a for loop in which all of the 
  144. generated values are displayed in a formatted list.  Compile and 
  145. run the program to see if it does what you expect it to do.  You 
  146. will need to remove line 24 if your compiler does not support 
  147. structure assignments.
  148.  
  149.  
  150. USING POINTERS AND STRUCTURES TOGETHER
  151. -----------------------------------------------------------------
  152. Examine the file named STRUCT3.C for an example   ===============
  153. of using pointers with structures.  This             STRUCT3.C
  154. program is identical to the last program except   ===============
  155. that it uses pointers for some of the operations.
  156.  
  157. The first difference shows up in the definition of variables 
  158. following the structure definition.  In this program we define a 
  159. pointer named point which is defined as a pointer that points to 
  160. the structure.  It would be illegal to try to use this pointer to 
  161. point to any other variable type.  There is a very definite 
  162. reason for this restriction in C as we have alluded to earlier 
  163. and will review in the next few paragraphs.
  164.  
  165. The next difference is in the for loop where we use the pointer 
  166. for accessing the data fields.  Recall from chapter 8 of this 
  167. tutorial that we said that the name of an array is actually a 
  168. pointer to the first element of the array.  Since kids is a 
  169. pointer variable that points to the first element of the array 
  170. which is a structure, we can define point in terms of kids.  The 
  171. variable kids is a constant so it cannot be changed in value, but 
  172.  
  173.                                                         Page 11-3
  174.  
  175.                                Chapter 11 - Structures and Unions
  176.  
  177. point is a pointer variable and can be assigned any value 
  178. consistent with its being required to point to the structure.  
  179. If we assign the value of kids to point then it should be clear 
  180. that point will also point to the first element of the array, a 
  181. structure containing three fields.  Figure 11-3 is a graphical 
  182. representation of the data space following the first pass through 
  183. the loop starting in line 14.
  184.  
  185.  
  186. POINTER ARITHMETIC
  187. -----------------------------------------------------------------
  188. Adding 1 to point will now cause it to point to the second field 
  189. of the array because of the way pointers are handled in C.  The 
  190. system knows that the structure contains three variables and it 
  191. knows how many memory elements are required to store the complete 
  192. structure.  Therefore if we tell it to add one to the pointer, it 
  193. will actually add the number of memory elements required to get 
  194. to the next element of the array.  If, for example, we were to 
  195. add 4 to the pointer, it would advance the value of the pointer 
  196. 4 times the size of the structure, resulting in it pointing 4 
  197. elements farther along the array.  This is the reason a pointer 
  198. cannot be used to point to any data type other than the one for 
  199. which it was defined.
  200.  
  201. Now to return to the program displayed on your monitor.  It 
  202. should be clear from the previous discussion that as we go 
  203. through the loop, the pointer will point to the beginning of one 
  204. of the array elements each time.  We can therefore use the 
  205. pointer to reference the various elements of each of the 
  206. structures as we go through the loop.  Referring to the elements 
  207. of a structure with a pointer occurs so often in C that a special 
  208. method of doing that was devised.  Using point->initial is the 
  209. same as using (*point).initial which is really the way we did it 
  210. in the last two programs.  Remember that *point is the stored 
  211. data to which the pointer points and the construct should be 
  212. clear.  The "->" is made up of the minus sign and the greater 
  213. than sign.  You will find experienced C programmers using this 
  214. pointer dereference profusely when you read their code in 
  215. magazines and other publications.
  216.  
  217. Since the pointer points to the structure, we must once again 
  218. define which of the elements we wish to refer to each time we 
  219. use one of the elements of the structure.  There are, as we 
  220. have seen, several different methods of referring to the members 
  221. of the structure.  When executing the for loop used for output at 
  222. the end of the program, we use three different methods of 
  223. referring to the structure elements.  This would be considered 
  224. very poor programming practice, but is done this way here to 
  225. illustrate to you that they all lead to the same result.  This 
  226. program will probably require some study on your part to fully 
  227. understand, but it will be worth your time and effort to grasp 
  228. these principles.
  229.  
  230.  
  231.                                                         Page 11-4
  232.  
  233.                                Chapter 11 - Structures and Unions
  234.  
  235. Lines 30 and 31 are two additional examples of structure 
  236. assignment which do nothing useful, but are included here for 
  237. your benefit.  Compile and run this program, and once again, if 
  238. your compiler does not support structure assignment, you will 
  239. need to remove lines 30 and 31.
  240.  
  241.  
  242. NESTED AND NAMED STRUCTURES
  243. -----------------------------------------------------------------
  244. Examine the file named NESTED.C for an example   ================
  245. of a nested structure.  The structures we have       NESTED.C
  246. seen so far have been very simple, although      ================
  247. useful.  It is possible to define structures 
  248. containing dozens and even hundreds or thousands of elements but 
  249. it would be to the programmers advantage not to define all of the 
  250. elements at one pass but rather to use a hierarchical structure 
  251. definition.  This will be illustrated with the program on your 
  252. monitor.
  253.  
  254. The first structure contains three elements but is followed by no 
  255. variable name.  We therefore have not defined any variables, only 
  256. a structure, but since we have included a name at the beginning 
  257. of the structure, the structure is named person.  The name person 
  258. can be used to refer to the structure but not to any variable of 
  259. this structure type.  It is therefore a new type that we have 
  260. defined, and we can use the new type in the same way we use int, 
  261. char, or any other types that exist in C.  The only restriction 
  262. is that this new name must always be associated with the keyword 
  263. struct.
  264.  
  265. The next structure definition contains three fields with the 
  266. middle field being the previously defined structure which we 
  267. named person.  The variable which has the type of person is named 
  268. descrip.  So the new structure contains two simple variables, 
  269. grade and a string named lunch, and the structure named descrip.  
  270. Since descrip contains three variables, the new structure 
  271. actually contains 5 variables.  This structure is also given a 
  272. name alldat, which is another type definition.  Finally we define 
  273. an array of 53 variables each with the structure defined by the 
  274. type alldat, and each with the name student.  If that is clear, 
  275. you will see that we have defined a total of 53 times 5 
  276. variables, each of which is capable of storing a value.  
  277.  
  278. Since we have a new type definition we can use it to define two 
  279. more variables.  The variables teacher and sub are defined in 
  280. line 20 to be variables of the type alldat, so that each of these 
  281. two variables contain 5 fields in which we can store data.  
  282. Figure 11-4 is a graphical representation of the variable named 
  283. teacher after it is defined in line 20.
  284.  
  285.  
  286.  
  287.  
  288.  
  289.                                                         Page 11-5
  290.  
  291.                                Chapter 11 - Structures and Unions
  292.  
  293. NOW TO USE SOME OF THE FIELDS
  294. -----------------------------------------------------------------
  295. In lines 22 through 26 of the program, we will assign values to 
  296. each of the fields of teacher.  The first field is the grade 
  297. field and is handled just like the other structures we have 
  298. studied because it is not part of the nested structure.  Next we 
  299. wish to assign a value to her age which is part of the nested 
  300. structure.  To address this field we start with the variable name 
  301. teacher to which we append the name of the group descrip, and 
  302. then we must define which field of the nested structure we are 
  303. interested in, so we append the variable name age.  The teachers 
  304. status is handled in exactly the same manner as her age, but the 
  305. last two fields are assigned strings using the string copy 
  306. function strcpy() which must be used for string assignment.  
  307. Notice that the variable names in the strcpy() function are 
  308. still variable names even though they are made up of several 
  309. parts each.
  310.  
  311. The variable sub is assigned nonsense values in much the same 
  312. way, but in a different order since they do not have to occur in 
  313. any required order.  Finally, a few of the student variables are 
  314. assigned values for illustrative purposes and the program ends.  
  315. None of the values are printed for illustration since several 
  316. were printed in the last examples.
  317.  
  318. Compile and run this program, but when you run it, you may get a 
  319. stack overflow error.  C uses its own internal stack to store the 
  320. automatic variables, but some C compilers use only a 2048 byte 
  321. stack as a default.  This program requires more than that for the 
  322. defined structures so it will be necessary for you to increase 
  323. the stack size.  Consult your compiler documentation for details 
  324. concerning the method of increasing the stack size.  There is no 
  325. standard way to do this.  There is another way around this 
  326. problem, and that is to move the variable definitions outside of 
  327. the main program where they will be external variables and 
  328. therefore static.  The result is that they will not be kept on 
  329. the internal stack and the stack will not overflow.  It would be 
  330. good experience for you to try both methods of fixing this 
  331. problem.
  332.  
  333.  
  334. MORE ABOUT STRUCTURES
  335. -----------------------------------------------------------------
  336. It is possible to continue nesting structures until you get 
  337. totally confused.  If you define them properly, the computer will 
  338. not get confused because there is no stated limit as to how many 
  339. levels of nesting are allowed.  There is probably a practical 
  340. limit of three beyond which you will probably get confused, but 
  341. the language has no limit.  In addition to nesting, you can 
  342. include as many structures as you desire in any level of 
  343. structures, such as defining another structure prior to alldat 
  344. and using it in alldat in addition to using person.  The 
  345.  
  346.  
  347.                                                         Page 11-6
  348.  
  349.                                Chapter 11 - Structures and Unions
  350.  
  351. structure named person could be included in alldat two or more 
  352. times if desired, as could pointers to it.
  353.  
  354. Structures can contain arrays of other structures which in turn 
  355. can contain arrays of simple types or other structures.  It can 
  356. go on and on until you lose all reason to continue.  I am only 
  357. trying to illustrate to you that structures are very valuable and 
  358. you will find them great aids to programming if you use them 
  359. wisely.  Be conservative at first, and get bolder as you gain 
  360. experience.  Keep in mind that a structure is designed to group 
  361. related data together.
  362.  
  363. More complex structures will not be illustrated here, but you 
  364. will find examples of additional structures in the example 
  365. programs included in the last chapter of this tutorial.  For 
  366. example, see the include file named VC.H on the distribution 
  367. disk. 
  368.  
  369.  
  370. WHAT ARE UNIONS?
  371. -----------------------------------------------------------------
  372. Examine the file named UNION1.C for an example   ================
  373. of a union.  Simply stated, a union allows you       UNION1.C
  374. a way to look at the same data with different    ================
  375. types, or to use the same data with different 
  376. names.  In this example we have two elements to the union, the 
  377. first part being the integer named value, which is stored as a 
  378. two byte variable somewhere in the computers memory.  The second 
  379. element is made up of two character variables named first and 
  380. second.  These two variables are stored in the same storage 
  381. locations that value is stored in, because that is what a union 
  382. does.  A union allows you to store different types of data in the 
  383. same physical storage locations.  In this case, you could put an 
  384. integer number in value, then retrieve it in its two halves by 
  385. getting each half using the two names first and second.  This 
  386. technique is often used to pack data bytes together when you are, 
  387. for example, combining bytes to be used in the registers of the 
  388. microprocessor.
  389.  
  390. Accessing the fields of the union are very similar to accessing 
  391. the fields of a structure and will be left to you to determine by 
  392. studying the example.
  393.  
  394. One additional note must be given here about the program.  When 
  395. it is run using some C compilers, the data will be displayed with 
  396. two leading f's due to the hexadecimal output promoting the char 
  397. type variables to int and extending the sign bit to the left.  
  398. Converting the char type data fields to int type fields prior to 
  399. display should remove the leading f's from your display.  This 
  400. will involve defining two new int type variables and assigning 
  401. the char type variables to them.  This will be left as an 
  402. exercise for you.  Note that the same problem will come up in a 
  403. few of the later files in this tutorial.
  404.  
  405.                                                         Page 11-7
  406.  
  407.                                Chapter 11 - Structures and Unions
  408.  
  409. Compile and run this program and observe that the data is read 
  410. out as an int and as two char variables.  The char variables may 
  411. be reversed in order because of the way an int variable is stored 
  412. internally in your computer.  If your system reverses these 
  413. variables, don't worry about it.  It is not a problem but it can 
  414. be a very interesting area of study if you are so inclined.
  415.  
  416.  
  417. ANOTHER UNION EXAMPLE
  418. -----------------------------------------------------------------
  419. Examine the file named UNION2.C for another     =================
  420. example of a union, one which is much more          UNION2.C
  421. common.  Suppose you wished to build a large    =================
  422. database including information on many types 
  423. of vehicles.  It would be silly to include the number of 
  424. propellers on a car, or the number of tires on a boat.  In order 
  425. to keep all pertinent data, however, you would need those data 
  426. points for their proper types of vehicles.  In order to build an 
  427. efficient data base, you would need several different types of 
  428. data for each vehicle, some of which would be common, and some of 
  429. which would be different.  That is exactly what we are doing in 
  430. the example program on your monitor.
  431.  
  432. In this program, we will define a complete structure, then decide 
  433. which of the various types can go into it.  We will start at the 
  434. top and work our way down.  First, we define a few constants with 
  435. the #defines, and begin the program itself.  We define a 
  436. structure named automobile containing several fields which you 
  437. should have no trouble recognizing, but we define no variables at 
  438. this time.
  439.  
  440.  
  441. A NEW CONCEPT, THE TYPEDEF
  442. -----------------------------------------------------------------
  443. Next we define a new type of data with a typedef.  This defines a 
  444. complete new type that can be used in the same way that int or 
  445. char can be used.  Notice that the structure has no name, but at 
  446. the end where there would normally be a variable name there is 
  447. the name BOATDEF.  We now have a new type, BOATDEF, that can be 
  448. used to define a structure anyplace we would like to.  Notice 
  449. that this does not define any variables, only a new type.  
  450. Capitalizing the name is a personal preference only and is not a 
  451. C standard but is used by most experienced C programmers.  It 
  452. makes the typedef look different from a variable name.
  453.  
  454. We finally come to the big structure that defines our data using 
  455. the building blocks already defined above.  The structure is 
  456. composed of 5 parts, two simple variables named vehicle and 
  457. weight, followed by the union, and finally the last two simple 
  458. variables named value and owner.  Of course the union is what we 
  459. need to look at carefully here, so focus on it for the moment.  
  460. You will notice that it is composed of four parts, the first part 
  461. being the variable car which is a structure that we defined 
  462.  
  463.                                                         Page 11-8
  464.  
  465.                                Chapter 11 - Structures and Unions
  466.  
  467. previously.  The second part is a variable named boat which is a 
  468. structure of the type BOATDEF previously defined.  The third part 
  469. of the union is the variable airplane which is a structure 
  470. defined in place in the union.  Finally we come to the last part 
  471. of the union, the variable named ship which is another structure 
  472. of the type BOATDEF.
  473.  
  474. I hope it is obvious to you that all four could have been defined 
  475. in any of the three ways shown, but the three different methods 
  476. were used to show you that any could be used.  In practice, the 
  477. clearest definition would probably have occurred by using the 
  478. typedef for each of the parts.
  479.  
  480.  
  481. WHAT DO WE HAVE NOW?
  482. -----------------------------------------------------------------
  483. We now have a structure that can be used to store any of four 
  484. different kinds of data structures.  The size of every record 
  485. will be the size of that record containing the largest union.  In 
  486. this case part 1 is the largest union because it is composed of 
  487. three integers, the others being composed of an integer and a 
  488. character each.  The first member of this union would therefore 
  489. determine the size of all structures of this type.  The resulting 
  490. structure can be used to store any of the four types of data, but 
  491. it is up to the programmer to keep track of what is stored in 
  492. each variable of this type.  The variable named vehicle was 
  493. designed into this structure to keep track of the type of vehicle 
  494. stored here.  The four defines at the top of the page were 
  495. designed to be used as indicators stored in the variable named 
  496. vehicle. 
  497.  
  498. A few examples of how to use the resulting structure are given in 
  499. the next few lines of the program.  Some of the variables are 
  500. defined and a few of them are printed out for illustrative 
  501. purposes. 
  502.  
  503. The union is not used too frequently, and almost never by 
  504. beginning programmers.  You will encounter it occasionally so it 
  505. is worth your effort to at least know what it is.  You do not 
  506. need to know the details of it at this time, so don't spend too 
  507. much time studying it.  When you do have a need for a variant 
  508. structure, a union, you can learn it at that time.  For your own 
  509. benefit, however, do not slight the structure.  You should use 
  510. the structure often.
  511.  
  512.  
  513. WHAT IS A BITFIELD?
  514. -----------------------------------------------------------------
  515. Load and display the program named BITFIELD.C    ================
  516. for an example of how to define and use a           BITFIELD.C
  517. bitfield.  In this program, we have a union      ================
  518. made up of a single int type variable in line 
  519. 5 and the structure defined in lines 6 through 10.  The structure 
  520.  
  521.                                                         Page 11-9
  522.  
  523.                                Chapter 11 - Structures and Unions
  524.  
  525. is composed of three bitfields named x, y, and z.  The variable 
  526. named x is only one bit wide, the variable y is two bits wide and 
  527. adjacent to the variable x, and the variable z is two bits wide 
  528. and adjacent to y.  Moreover, because the union causes the bits 
  529. to be stored in the same memory location as the variable index, 
  530. the variable x is the least significant bit of the variable 
  531. index, y is the next two bits, and z is stored in the next two 
  532. bits of index.
  533.  
  534. Compile and run the program and you will see that as the variable 
  535. index is incremented by one each time through the loop, and you 
  536. will see the bitfields of the union counting due to their 
  537. respective locations within the int definition.
  538.  
  539. One thing must be pointed out, the bitfields must be defined as 
  540. parts of an unsigned int or your compiler will issue an error 
  541. message.
  542.  
  543.  
  544. WHAT IS THE BITFIELD GOOD FOR?
  545. -----------------------------------------------------------------
  546. The bitfield is very useful if you have a lot of data to separate 
  547. into individual bits or groups of bits.  Many systems use some 
  548. sort of a packed format to get lots of data stored in a few 
  549. bytes.  Your imagination is your only limitation to the efficient 
  550. use of this feature of C. 
  551.  
  552.  
  553. MORE STYLE ISSUES
  554. -----------------------------------------------------------------
  555. Examine the file named STYLE3.H for our first    ================
  556. example of a header file that really looks           STYLE3.H
  557. like one.  You will notice several constant      ================
  558. definitions, a few structure definitions, and 
  559. some prototypes.  Nothing in this file generates anything that 
  560. uses memory, since there are no variables defined and no code is 
  561. defined here.  Each of those use some memory, but all of the 
  562. constructs in this file do nothing but create definitions which 
  563. are then used by other portions of the program.  This header 
  564. file, if it is general enough, can be used by many different 
  565. implementations.
  566.  
  567. Spend a few minutes and observe the style.  Take notice 
  568. especially of the order of the various entities.  The constants 
  569. are defined first, followed by the structures since they 
  570. generally use one or more of the constants.  Finally, the 
  571. prototypes are defined since they often make use of one or more 
  572. of the structures in their parameter lists or their return 
  573. values.
  574.  
  575.  
  576.  
  577.  
  578.  
  579.                                                        Page 11-10
  580.  
  581.                                Chapter 11 - Structures and Unions
  582.  
  583. Examine the file named STYLE3.C which uses some  ================
  584. of the definitions in the header STYLE3.H            STYLE3.C
  585. header file.  The observant student will notice  ================
  586. that not everything that is defined in the 
  587. header file is used in this implementation file, and it really 
  588. doesn't need to be.  Since a header file is meant to be general 
  589. purpose, all things within the file will not be used every time 
  590. the file itself is used in a program.
  591.  
  592. In this case, the structure named alldat is used in lines 14 and 
  593. 15, after being included here in line 10.  The rest of the 
  594. program is written in exactly the same manner that it was 
  595. written when we defined the structure locally.  This program can 
  596. be compiled and executed just like all of the other programs in 
  597. this tutorial.
  598.  
  599.  
  600. PROGRAMMING EXERCISES
  601. -----------------------------------------------------------------
  602. 1.  Define a named structure containing a string for a name, an 
  603.     integer for feet, and another for arms.  Use the new type to 
  604.     define an array of about 6 items.  Fill the fields with data 
  605.     and print them out as follows.
  606.     
  607.        A human being has 2 legs and 2 arms.    
  608.        A dog has 4 legs and 0 arms.    
  609.        A television set has 4 legs and 0 arms. 
  610.        A chair has 4 legs and 2 arms.   
  611.          etc.
  612.     
  613. 2.  Rewrite exercise 1 using a pointer to print the data out.
  614.  
  615.  
  616.  
  617.  
  618.  
  619.  
  620.  
  621.  
  622.  
  623.  
  624.  
  625.  
  626.  
  627.  
  628.  
  629.  
  630.  
  631.  
  632.  
  633.  
  634.  
  635.  
  636.  
  637.                                                        Page 11-11
  638.